const axios = require('axios');
const { response } = require('express');
class outController {
    // 获取天气预报
    async getWeather(req, res) {
        try {
            const { location, data_type = 'all' } = req.query;
            if (!location) {
                return res.status(-1).json({
                    code: -1,
                    msg: '缺少location参数'
                });
            }

            // 百度天气API配置
            const ak = 'h3SaacqB2OU5RLTmyLV89LkDoQCDmpRb';
            const url = 'https://api.map.baidu.com/weather/v1/';

            // 构造请求参数
            const params = {
                data_type,
                ak,
                location
            };

            // 发起请求
            await axios.get(url, { params })
                .then(
                    result => {
                        // 返回结果
                        res.json({
                            code: 200,
                            msg: '天气预报数据查询成功',
                            data: result.data
                        })
                    },
                    err => {
                        res.status(500).json({
                            code: 500,
                            msg: '服务器内部错误',
                            err: err
                        })
                    }
                )
        } catch (error) {
            console.error('天气查询错误:', error);
            res.status(500).json({
                code: 500,
                msg: '服务器内部错误'
            });
        }
    }


    // 获取随机一言
    async getRandomText(req, res) {
        const url = 'https://api.cenguigui.cn/api/yiyan/';
        await axios.get(url)
            .then(
                result => {
                    res.json({
                        code: 200,
                        msg: '获取随机一言成功',
                        text: result.data
                    })
                },
                err => {
                    res.json({
                        code: 500,
                        msg: "获取随机一言失败",
                        err: err
                    })
                }
            )
    }


    async getAiChat(req, res) {
        const text = req.body.text;
        if (!text) {
            return res.status(400).json({
                code: 400,
                msg: '缺少text参数或text参数为空'
            });
        }
        const url = 'https://api.siliconflow.cn/v1/chat/completions';
        const requestData = {
            model: "Qwen/Qwen2.5-Coder-7B-Instruct",
            messages: [
                { "role": "assistant", "content": "你好呀，我是你的AI助手，请问有什么可以帮你？" }, //第一条是助手的欢迎语（assistant角色）
                { "role": "user", "content": text } //第二条是用户输入的内容（user角色）
            ],
            stream: false, // 设置为非流式响应，即一次性返回完整结果而不是逐步返回（false为非流式，true为逐步返回结果）
            max_tokens: 4096, //设置AI生成回复的最大token数为4096
            temperature: 0.7, //设置随机性参数，0.7表示中等创造性
            top_p: 0.7
            // 移除或正确配置tools部分
        };
        const options = {
            method: 'POST',
            url: url,
            headers: {
                Authorization: 'Bearer sk-fwubmrhhxrbvzukxfefhgukvppgqodsvdbkbmmijjkqyojky',
                //  使用Bearer Token进行身份验证
                'Content-Type': 'application/json'
                //  指定发送的数据格式为JSON
            },
            data: requestData
        };

        try {
            const result = await axios(options)
            res.status(200).json({
                code: 200,
                msg: '获取对话成功',
                result: result.data
            })
        } catch (err) {
            res.status(500).json({
                code: 500,
                msg: '获取对话失败',
                result: err
            })
        }
    }

    async getAiChatStream(req, res) {
        const text = req.body.text;
        if (!text) {
            return res.status(400).json({
                code: 400,
                msg: '缺少text参数或text参数为空'
            });
        }

        const url = 'https://api.siliconflow.cn/v1/chat/completions';
        const requestData = {
            model: "Qwen/QwQ-32B",
            messages: [{ role: "user", content: text }],
            stream: true
        };

        try {
            const response = await axios.post(url, requestData, {
                headers: {
                    Authorization: 'Bearer sk-fwubmrhhxrbvzukxfefhgukvppgqodsvdbkbmmijjkqyojky',
                    'Content-Type': 'application/json'
                },
                responseType: 'stream' // 关键：启用流式响应
            });

            // 设置响应头为 SSE（Server-Sent Events）
            res.setHeader('Content-Type', 'text/event-stream');
            res.setHeader('Cache-Control', 'no-cache');
            res.setHeader('Connection', 'keep-alive');

            // 监听流式数据
            response.data.on('data', chunk => {
                const chunkStr = chunk.toString();


                // 解析 data: {"content": "..."} 格式
                const regex = /data:.*?"content":\s*"([^"]*?)"/;
                const match = chunkStr.match(regex);
                if (match && match[1]) {
                    const contentValue = match[1];
                    res.write(`${contentValue}`);
                }
            });

            // // 在这里监听 end 事件，只执行一次
            response.data.on('end', () => {
                res.write(`''`);
                res.end(); // 关闭响应流
            });

            response.data.on('error', err => {
                console.error(err);
                res.status(500).json({
                    code: 500,
                    msg: '获取对话失败',
                    result: err.message
                });
            });
        } catch (err) {
            console.error(err);
            res.status(500).json({
                code: 500,
                msg: '获取对话失败',
                result: err.message
            });
        }
    }

}

module.exports = new outController();